3 /***************************************************************************\
4 * SPIP, Systeme de publication pour l'internet *
6 * Copyright (c) 2001-2011 *
7 * Arnaud Martin, Antoine Pitrou, Philippe Riviere, Emmanuel Saint-James *
9 * Ce programme est un logiciel libre distribue sous licence GNU/GPL. *
10 * Pour plus de details voir le fichier COPYING.txt ou l'aide en ligne. *
11 \***************************************************************************/
13 if (!defined('_ECRIRE_INC_VERSION')) return;
16 // il ne faut pas avoir de PDO::CONSTANTE dans ce fichier sinon php4 se tue !
17 // idem, il ne faut pas de $obj->toto()->toto sinon php4 se tue !
19 # todo : get/set_caracteres ?
24 * regroupe le maximum de fonctions qui peuvent cohabiter
25 * D'abord les fonctions d'abstractions de SPIP
28 // http://doc.spip.org/@req_sqlite_dist
29 function req_sqlite_dist($addr, $port, $login, $pass, $db='', $prefixe='', $sqlite_version=''){
30 static $last_connect = array();
32 // si provient de selectdb
33 // un code pour etre sur que l'on vient de select_db()
34 if (strpos($db, $code = '@selectdb@')!==false) {
35 foreach (array('addr','port','login','pass','prefixe') as $a){
36 $
$a = $last_connect[$a];
38 $db = str_replace($code, '', $db);
42 * En sqlite, seule l'adresse du fichier est importante.
43 * Ce sera $db le nom, et le path _DIR_DB
47 // un nom de base demande et impossible d'obtenir la base, on s'en va
48 if ($db && !is_file($f = _DIR_DB
. $db . '.sqlite') && !is_writable(_DIR_DB
))
52 // charger les modules sqlite au besoin
53 if (!_sqlite_charger_version($sqlite_version)) {
54 spip_log("Impossible de trouver/charger le module SQLite ($sqlite_version)!");
58 // chargement des constantes
59 // il ne faut pas definir les constantes avant d'avoir charge les modules sqlite
60 $define = "spip_sqlite".$sqlite_version."_constantes";
65 // si installation -> base temporaire tant qu'on ne connait pas son vrai nom
66 if (defined('_ECRIRE_INSTALL') && _ECRIRE_INSTALL
){
67 // creation d'une base temporaire pour le debut d'install
68 $db = "_sqlite".$sqlite_version."_install";
69 $tmp = _DIR_DB
. $db . ".sqlite";
70 if ($sqlite_version == 3) {
71 $ok = $link = new PDO("sqlite:$tmp");
73 $ok = $link = sqlite_open($tmp, _SQLITE_CHMOD
, $err);
75 // sinon, on arrete finalement
80 // Ouvrir (eventuellement creer la base)
81 // si pas de version fourni, on essaie la 3, sinon la 2
82 if ($sqlite_version == 3) {
83 $ok = $link = new PDO("sqlite:$f");
85 $ok = $link = sqlite_open($f, _SQLITE_CHMOD
, $err);
90 spip_log("Impossible d'ouvrir la base de donnee SQLite ($sqlite_version) : $f ");
95 $last_connect = array (
101 'prefixe' => $prefixe,
107 'prefixe' => $prefixe ?
$prefixe : $db,
114 // Fonction de requete generale, munie d'une trace a la demande
115 // http://doc.spip.org/@spip_sqlite_query
116 function spip_sqlite_query($query, $serveur='',$requeter=true) {
117 #spip_log("spip_sqlite_query() > $query");
120 $requete = new sqlite_traiter_requete($query, $serveur);
121 $requete->traduire_requete(); // mysql -> sqlite
122 if (!$requeter) return $requete->query
;
123 return $requete->executer_requete();
127 /* ordre alphabetique pour les autres */
129 // http://doc.spip.org/@spip_sqlite_alter
130 function spip_sqlite_alter($query, $serveur='',$requeter=true){
132 $query = spip_sqlite_query("ALTER $query",$serveur,false);
135 * la il faut faire les transformations
136 * si ALTER TABLE x (DROP|CHANGE) y
138 * 1) recuperer "ALTER TABLE table "
139 * 2) spliter les sous requetes (,)
140 * 3) faire chaque requete independemment
144 if (preg_match("/\s*(ALTER(\s*IGNORE)?\s*TABLE\s*([^\s]*))\s*(.*)?/is", $query, $regs)){
149 spip_log("SQLite : Probleme de ALTER TABLE mal forme dans $query", 'sqlite');
154 // il faudrait une regexp pour eviter de spliter ADD PRIMARY KEY (colA, colB)
155 // tout en cassant "ADD PRIMARY KEY (colA, colB), ADD INDEX (chose)"... en deux
156 // ou revoir l'api de sql_alter en creant un
157 // sql_alter_table($table,array($actions));
158 $todo = explode(',', $suite);
160 // on remet les morceaux dechires ensembles... que c'est laid !
161 $todo2 = array(); $i=0;
163 while ($do = array_shift($todo)) {
164 $todo2[$i] = isset($todo2[$i]) ?
$todo2[$i] . "," . $do : $do;
165 $o=(false!==strpos($do,"("));
166 $f=(false!==strpos($do,")"));
167 if ($o AND !$f) $ouverte=true;
168 elseif ($f) $ouverte=false;
173 $resultats = array();
174 foreach ($todo2 as $do){
176 if (!preg_match('/(DROP PRIMARY KEY|DROP INDEX|DROP COLUMN|DROP'
177 .'|CHANGE COLUMN|CHANGE|MODIFY|RENAME TO|RENAME'
178 .'|ADD PRIMARY KEY|ADD INDEX|ADD COLUMN|ADD'
179 .')\s*([^\s]*)\s*(.*)?/', $do, $matches)){
180 spip_log("SQLite : Probleme de ALTER TABLE, utilisation non reconnue dans : $do \n(requete d'origine : $query)", 'sqlite');
184 $cle = strtoupper($matches[1]);
185 $colonne_origine = $matches[2];
186 $colonne_destination = '';
190 // eluder une eventuelle clause before|after|first inutilisable
191 $defr = rtrim(preg_replace('/(BEFORE|AFTER|FIRST)(.*)$/is','', $def));
192 // remplacer les definitions venant de mysql
193 $defr = _sqlite_remplacements_definitions_table($defr);
195 // reinjecter dans le do
196 $do = str_replace($def,$defr,$do);
200 // suppression d'un index
202 $nom_index = $colonne_origine;
203 spip_sqlite_drop_index($nom_index, $table, $serveur);
206 // suppression d'une pk
207 case 'DROP PRIMARY KEY':
208 if (!_sqlite_modifier_table(
211 array('key'=>array('PRIMARY KEY'=>'')),
216 // suppression d'une colonne
219 if (!_sqlite_modifier_table(
221 array($colonne_origine=>""),
228 case 'CHANGE COLUMN':
230 // recuperer le nom de la future colonne
232 $colonne_destination = substr($def, 0, strpos($def,' '));
233 $def = substr($def, strlen($colonne_destination)+
1);
235 if (!_sqlite_modifier_table(
237 array($colonne_origine=>$colonne_destination),
238 array('field'=>array($colonne_destination=>$def)),
245 if (!_sqlite_modifier_table(
248 array('field'=>array($colonne_origine=>$def)),
254 // pas geres en sqlite2
256 $do = "RENAME TO" . substr($do,6);
258 if (_sqlite_is_version(3, '', $serveur)){
259 $requete = new sqlite_traiter_requete("$debut $do", $serveur);
260 if (!$requete->executer_requete()){
261 spip_log("SQLite : Erreur ALTER TABLE / RENAME : $query", 'sqlite');
264 // artillerie lourde pour sqlite2 !
266 $table_dest = trim(substr($do, 9));
267 if (!_sqlite_modifier_table(array($table=>$table_dest), '', '', $serveur)){
268 spip_log("SQLite : Erreur ALTER TABLE / RENAME : $query", 'sqlite');
275 case 'ADD PRIMARY KEY':
276 $pk = trim(substr($do,16));
277 $pk = ($pk[0]=='(') ?
substr($pk,1,-1) : $pk;
278 if (!_sqlite_modifier_table(
281 array('key'=>array('PRIMARY KEY'=>$pk)),
288 // peut etre "(colonne)" ou "nom_index (colonnes)"
289 // bug potentiel si qqn met "(colonne, colonne)"
291 // nom_index (colonnes)
293 $colonnes = substr($def,1,-1);
294 $nom_index = $colonne_origine;
298 if ($colonne_origine[0] == "(") {
299 $colonnes = substr($colonne_origine,1,-1);
300 if (false!==strpos(",",$colonnes)) {
301 spip_log("SQLite : Erreur, impossible de creer un index sur plusieurs colonnes"
302 ." sans qu'il ait de nom ($table, ($colonnes))", 'sqlite');
305 $nom_index = $colonnes;
310 $nom_index = $colonnes = $colonne_origine ;
313 spip_sqlite_create_index($nom_index, $table, $colonnes, $serveur);
316 // pas geres en sqlite2
318 $do = "ADD".substr($do, 10);
321 if (_sqlite_is_version(3, '', $serveur)){
322 $requete = new sqlite_traiter_requete("$debut $do", $serveur);
323 if (!$requete->executer_requete()){
324 spip_log("SQLite : Erreur ALTER TABLE / ADD : $query", 'sqlite');
328 // artillerie lourde pour sqlite2 !
330 $def = trim(substr($do, 3));
331 $colonne_ajoutee = substr($def, 0, strpos($def,' '));
332 $def = substr($def, strlen($colonne_ajoutee)+
1);
333 if (!_sqlite_modifier_table($table, array($colonne_ajoutee), array('field'=>array($colonne_ajoutee=>$def)), $serveur)){
334 spip_log("SQLite : Erreur ALTER TABLE / ADD : $query", 'sqlite');
340 // tout est bon, ouf !
341 spip_log("SQLite ($serveur) : Changements OK : $debut $do");
344 spip_log("SQLite ($serveur) : fin ALTER TABLE OK !");
349 // Fonction de creation d'une table SQL nommee $nom
350 // http://doc.spip.org/@spip_sqlite_create
351 function spip_sqlite_create($nom, $champs, $cles, $autoinc=false, $temporary=false, $serveur='',$requeter=true) {
352 $query = _sqlite_requete_create($nom, $champs, $cles, $autoinc, $temporary, $ifnotexists=true, $serveur, $requeter);
353 if (!$query) return false;
354 $res = spip_sqlite_query($query, $serveur, $requeter);
356 // SQLite ne cree pas les KEY sur les requetes CREATE TABLE
357 // il faut donc les faire creer ensuite
358 if (!$requeter) return $res;
360 $ok = $res ?
true : false;
362 foreach($cles as $k=>$v) {
363 if (strpos($k, "KEY ") === 0) {
364 $index = preg_replace("/KEY +/", '',$k);
365 $ok &= $res = spip_sqlite_create_index($index, $nom, $v, $serveur);
369 return $ok ?
true : false;
373 * Fonction pour creer une base de donnees SQLite
375 * @param string $nom le nom de la base (sans l'extension de fichier)
376 * @param string $serveur le nom de la connexion
377 * @param string $option options
379 * @return bool true si la base est creee.
381 function spip_sqlite_create_base($nom, $serveur='', $option=true) {
382 $f = _DIR_DB
. $nom . '.sqlite';
383 if (_sqlite_is_version(2, '', $serveur)) {
384 $ok = sqlite_open($f, _SQLITE_CHMOD
, $err);
386 $ok = new PDO("sqlite:$f");
397 // Fonction de creation d'une vue SQL nommee $nom
398 // http://doc.spip.org/@spip_sqlite_create_view
399 function spip_sqlite_create_view($nom, $query_select, $serveur='',$requeter=true) {
400 if (!$query_select) return false;
402 if (sql_showtable($nom, false, $serveur)) {
403 spip_log("Echec creation d'une vue sql ($nom) car celle-ci existe deja (serveur:$serveur)");
407 $query = "CREATE VIEW $nom AS ". $query_select;
408 return spip_sqlite_query($query, $serveur, $requeter);
412 * Fonction de creation d'un INDEX
414 * @param string $nom : nom de l'index
415 * @param string $table : table sql de l'index
416 * @param string/array $champs : liste de champs sur lesquels s'applique l'index
417 * @param string $serveur : nom de la connexion sql utilisee
418 * @param bool $requeter : true pour executer la requete ou false pour retourner le texte de la requete
420 * @return bool ou requete
422 function spip_sqlite_create_index($nom, $table, $champs, $serveur='', $requeter=true) {
423 if (!($nom OR $table OR $champs)) {
424 spip_log("Champ manquant pour creer un index sqlite ($nom, $table, (".join(',',$champs)."))");
428 // SQLite ne differentie pas noms des index en fonction des tables
429 // il faut donc creer des noms uniques d'index pour une base sqlite
430 $nom = $table.'_'.$nom;
431 // enlever d'eventuelles parentheses deja presentes sur champs
432 if (!is_array($champs)){
433 if ($champs[0]=="(") $champs = substr($champs,1,-1);
434 $champs = array($champs);
436 $query = "CREATE INDEX $nom ON $table (" . join(',',$champs) . ")";
437 $res = spip_sqlite_query($query, $serveur, $requeter);
438 if (!$requeter) return $res;
445 // en PDO/sqlite3, il faut calculer le count par une requete count(*)
446 // pour les resultats de SELECT
447 // cela est fait sans spip_sqlite_query()
448 // http://doc.spip.org/@spip_sqlite_count
449 function spip_sqlite_count($r, $serveur='',$requeter=true) {
452 if (_sqlite_is_version(3, '', $serveur)){
453 // select ou autre (insert, update,...) ?
454 if (isset($r->spipSqliteRowCount
)) {
455 // Ce compte est faux s'il y a des limit dans la requete :(
456 // il retourne le nombre d'enregistrements sans le limit
457 return $r->spipSqliteRowCount
;
459 return $r->rowCount();
462 return sqlite_num_rows($r);
467 // http://doc.spip.org/@spip_sqlite_countsel
468 function spip_sqlite_countsel($from = array(), $where = array(), $groupby = '', $having = array(), $serveur='',$requeter=true) {
469 $c = !$groupby ?
'*' : ('DISTINCT ' . (is_string($groupby) ?
$groupby : join(',', $groupby)));
470 $r = spip_sqlite_select("COUNT($c)", $from, $where,'', '', '',$having, $serveur, $requeter);
471 if ((is_resource($r) or is_object($r)) && $requeter) { // ressource : sqlite2, object : sqlite3
472 if (_sqlite_is_version(3,'',$serveur)){
473 list($n) = spip_sqlite_fetch($r, SPIP_SQLITE3_NUM
, $serveur);
475 list($n) = spip_sqlite_fetch($r, SPIP_SQLITE2_NUM
, $serveur);
477 spip_sqlite_free($r,$serveur);
484 // http://doc.spip.org/@spip_sqlite_delete
485 function spip_sqlite_delete($table, $where='', $serveur='',$requeter=true) {
486 $res = spip_sqlite_query(
487 _sqlite_calculer_expression('DELETE FROM', $table, ',')
488 . _sqlite_calculer_expression('WHERE', $where),
489 $serveur, $requeter);
491 // renvoyer la requete inerte si demandee
492 if (!$requeter) return $res;
495 $link = _sqlite_link($serveur);
496 if (_sqlite_is_version(3, $link)) {
497 return $res->rowCount();
499 return sqlite_changes($link);
507 // http://doc.spip.org/@spip_sqlite_drop_table
508 function spip_sqlite_drop_table($table, $exist='', $serveur='',$requeter=true) {
509 if ($exist) $exist =" IF EXISTS";
511 /* simuler le IF EXISTS - version 2 */
512 if ($exist && _sqlite_is_version(2, '', $serveur)){
513 $a = spip_sqlite_showtable($table, $serveur);
514 if (!$a) return true;
517 if (spip_sqlite_query("DROP TABLE$exist $table", $serveur, $requeter))
524 // http://doc.spip.org/@spip_sqlite_drop_view
525 function spip_sqlite_drop_view($view, $exist='', $serveur='',$requeter=true) {
526 if ($exist) $exist =" IF EXISTS";
528 /* simuler le IF EXISTS - version 2 */
529 if ($exist && _sqlite_is_version(2, '', $serveur)){
530 $a = spip_sqlite_showtable($view, $serveur);
531 if (!$a) return true;
535 return spip_sqlite_query("DROP VIEW$exist $view", $serveur, $requeter);
539 * Fonction de suppression d'un INDEX
541 * @param string $nom : nom de l'index
542 * @param string $table : table sql de l'index
543 * @param string $serveur : nom de la connexion sql utilisee
544 * @param bool $requeter : true pour executer la requete ou false pour retourner le texte de la requete
546 * @return bool ou requete
548 function spip_sqlite_drop_index($nom, $table, $serveur='', $requeter=true) {
549 if (!($nom OR $table)) {
550 spip_log("Champ manquant pour supprimer un index sqlite ($nom, $table)");
554 // SQLite ne differentie pas noms des index en fonction des tables
555 // il faut donc creer des noms uniques d'index pour une base sqlite
556 $index = $table.'_'.$nom;
557 $exist =" IF EXISTS";
559 /* simuler le IF EXISTS - version 2 */
560 if (_sqlite_is_version(2, '', $serveur)){
561 $a = spip_sqlite_showtable($table, $serveur);
562 if (!isset($a['key']['KEY '.$nom])) return true;
566 $query = "DROP INDEX$exist $index";
567 return spip_sqlite_query($query, $serveur, $requeter);
571 * Retourne la derniere erreur generee
573 * @param $serveur nom de la connexion
574 * @return string erreur eventuelle
576 // http://doc.spip.org/@spip_sqlite_error
577 function spip_sqlite_error($query='', $serveur='') {
578 $link = _sqlite_link($serveur);
580 if (_sqlite_is_version(3, $link)) {
581 $errs = $link->errorInfo();
583 foreach($errs as $n=>$e){
587 $s = sqlite_error_string(sqlite_last_error($link));
589 $s = ": aucune ressource sqlite (link)";
591 if ($s) spip_log("$s - $query", 'sqlite');
596 * Retourne le numero de la derniere erreur SQL
597 * (sauf que SQLite semble ne connaitre que 0 ou 1)
599 * @param $serveur nom de la connexion
600 * @return int 0 pas d'erreur / 1 une erreur
602 // http://doc.spip.org/@spip_sqlite_errno
603 function spip_sqlite_errno($serveur='') {
604 $link = _sqlite_link($serveur);
606 if (_sqlite_is_version(3, $link)){
607 $t = $link->errorInfo();
610 $s = sqlite_last_error($link);
612 $s = ": aucune ressource sqlite (link)";
615 if ($s) spip_log("Erreur sqlite $s");
621 // http://doc.spip.org/@spip_sqlite_explain
622 function spip_sqlite_explain($query, $serveur='',$requeter=true){
623 if (strpos(ltrim($query), 'SELECT') !== 0) return array();
625 $requete = new sqlite_traiter_requete("$query", $serveur);
626 $requete->traduire_requete(); // mysql -> sqlite
627 $requete->query
= 'EXPLAIN ' . $requete->query
;
628 if (!$requeter) return $requete;
629 // on ne trace pas ces requetes, sinon on obtient un tracage sans fin...
630 $requete->tracer
= false;
631 $r = $requete->executer_requete();
633 return $r ?
spip_sqlite_fetch($r, null, $serveur) : false; // hum ? etrange ca... a verifier
637 // http://doc.spip.org/@spip_sqlite_fetch
638 function spip_sqlite_fetch($r, $t='', $serveur='',$requeter=true) {
640 $link = _sqlite_link($serveur);
642 if (_sqlite_is_version(3, $link)) {
643 $t = SPIP_SQLITE3_ASSOC
;
645 $t = SPIP_SQLITE2_ASSOC
;
650 if (_sqlite_is_version(3, $link)){
651 if ($r) $retour = $r->fetch($t);
653 $retour = sqlite_fetch_array($r, $t);
656 // les version 2 et 3 parfois renvoie des 'table.titre' au lieu de 'titre' tout court ! pff !
657 // suppression de 'table.' pour toutes les cles (c'est un peu violent !)
660 foreach ($retour as $cle=>$val){
661 if (($pos = strpos($cle, '.'))!==false){
662 $cle = substr($cle,++
$pos);
673 function spip_sqlite_seek($r, $row_number, $serveur='',$requeter=true) {
675 $link = _sqlite_link($serveur);
676 if (_sqlite_is_version(3, $link)){
677 // encore un truc de bien fichu : PDO ne PEUT PAS faire de seek ou de rewind...
678 // je me demande si pour sqlite 3 il ne faudrait pas mieux utiliser
679 // les nouvelles fonctions sqlite3_xx (mais encore moins presentes...)
683 return sqlite_seek($r, $row_number);
689 // http://doc.spip.org/@spip_sqlite_free
690 function spip_sqlite_free(&$r, $serveur='',$requeter=true) {
693 //return sqlite_free_result($r);
697 // http://doc.spip.org/@spip_sqlite_get_charset
698 function spip_sqlite_get_charset($charset=array(), $serveur='',$requeter=true){
699 //$c = !$charset ? '' : (" LIKE "._q($charset['charset']));
700 //return spip_sqlite_fetch(sqlite_query(_sqlite_link($serveur), "SHOW CHARACTER SET$c"), NULL, $serveur);
704 // http://doc.spip.org/@spip_sqlite_hex
705 function spip_sqlite_hex($v){
710 // http://doc.spip.org/@spip_sqlite_in
711 function spip_sqlite_in($val, $valeurs, $not='', $serveur='',$requeter=true) {
714 while ($n = strpos($valeurs, ',', $n+
1)) {
716 $in_sql .= "($val $not IN (" .
717 substr($valeurs, 0, $n) .
719 ($not ?
"AND\t" : "OR\t");
720 $valeurs = substr($valeurs, $n+
1);
724 $in_sql .= "($val $not IN ($valeurs))";
730 // http://doc.spip.org/@spip_sqlite_insert
731 function spip_sqlite_insert($table, $champs, $valeurs, $desc='', $serveur='',$requeter=true) {
733 $connexion = $GLOBALS['connexions'][$serveur ?
$serveur : 0];
734 $prefixe = $connexion['prefixe'];
735 $sqlite = $connexion['link'];
736 $db = $connexion['db'];
738 if ($prefixe) $table = preg_replace('/^spip/', $prefixe, $table);
741 if (isset($_GET['var_profile'])) {
742 include_spip('public/tracer');
743 $t = trace_query_start();
746 $query="INSERT INTO $table ".($champs?
"$champs VALUES $valeurs":"DEFAULT VALUES");
749 if ($r = spip_sqlite_query($query, $serveur, $requeter)) {
750 if (!$requeter) return $r;
752 if (_sqlite_is_version(3, $sqlite)) $nb = $sqlite->lastInsertId();
753 else $nb = sqlite_last_insert_rowid($sqlite);
756 $err = spip_sqlite_error($query, $serveur);
757 return $t ?
trace_query_end($query, $t, $nb, $err, $serveur) : $nb;
762 // http://doc.spip.org/@spip_sqlite_insertq
763 function spip_sqlite_insertq($table, $couples=array(), $desc=array(), $serveur='',$requeter=true) {
764 if (!$desc) $desc = description_table($table);
765 if (!$desc) die("$table insertion sans description");
766 $fields = isset($desc['field'])?
$desc['field']:array();
768 foreach ($couples as $champ => $val) {
769 $couples[$champ]= _sqlite_calculer_cite($val, $fields[$champ]);
772 // recherche de champs 'timestamp' pour mise a jour auto de ceux-ci
773 $couples = _sqlite_ajouter_champs_timestamp($table, $couples, $desc, $serveur);
775 // si aucun champ donne pour l'insertion, on en cherche un avec un DEFAULT
776 // sinon sqlite3 ne veut pas inserer
777 $cles = $valeurs = "";
778 if (count($couples)) {
779 $cles = "(".join(',',array_keys($couples)).")";
780 $valeurs = "(".join(',', $couples).")";
783 return spip_sqlite_insert($table, $cles , $valeurs , $desc, $serveur, $requeter);
788 // http://doc.spip.org/@spip_sqlite_insertq_multi
789 function spip_sqlite_insertq_multi($table, $tab_couples=array(), $desc=array(), $serveur='',$requeter=true) {
790 foreach ($tab_couples as $couples) {
791 $retour = spip_sqlite_insertq($table, $couples, $desc, $serveur, $requeter);
793 // renvoie le dernier id d'autoincrement ajoute
799 // http://doc.spip.org/@spip_sqlite_listdbs
800 function spip_sqlite_listdbs($serveur='',$requeter=true) {
803 if (!is_dir($d = substr(_DIR_DB
,0,-1))){
807 include_spip('inc/flock');
808 $bases = preg_files($d, $pattern = '(.*)\.sqlite$');
811 foreach($bases as $b){
812 // pas de bases commencant pas sqlite
813 // (on s'en sert pour l'installation pour simuler la presence d'un serveur)
814 // les bases sont de la forme _sqliteX_tmp_spip_install.sqlite
815 if (strpos($b, '_sqlite')) continue;
816 $bds[] = preg_replace(";.*/$pattern;iS",'$1', $b);
823 // http://doc.spip.org/@spip_sqlite_multi
824 function spip_sqlite_multi ($objet, $lang) {
829 . "[\]]([^\[]*).*</multi>', '$1') AS multi";
835 * Optimise une table SQL
836 * Note: Sqlite optimise TOUTE un fichier sinon rien.
837 * On evite donc 2 traitements sur la meme base dans un hit.
839 * @param $table nom de la table a optimiser
840 * @param $serveur nom de la connexion
841 * @param $requeter effectuer la requete ? sinon retourner son code
842 * @return bool|string true / false / requete
844 // http://doc.spip.org/@spip_sqlite_optimize
845 function spip_sqlite_optimize($table, $serveur='', $requeter=true) {
847 if ($requeter and $do) {return true;}
848 if ($requeter) { $do = true; }
849 return spip_sqlite_query("VACUUM", $serveur, $requeter);
853 // avoir le meme comportement que _q()
854 function spip_sqlite_quote($v, $type=''){
855 if (is_array($v)) return join(",", array_map('spip_sqlite_quote', $v));
856 if (is_int($v)) return strval($v);
857 if (strncmp($v,'0x',2)==0 AND ctype_xdigit(substr($v,2))) return hexdec(substr($v,2));
858 if ($type === 'int' AND !$v) return '0';
860 if (function_exists('sqlite_escape_string')) {
861 return "'" . sqlite_escape_string($v) . "'";
864 // trouver un link sqlite3 pour faire l'echappement
865 foreach ($GLOBALS['connexions'] as $s) {
866 if (_sqlite_is_version(3, $l = $s['link'])){
867 return $l->quote($v);
874 * Tester si une date est proche de la valeur d'un champ
876 * @param string $champ le nom du champ a tester
877 * @param int $interval valeur de l'interval : -1, 4, ...
878 * @param string $unite utite utilisee (DAY, MONTH, YEAR, ...)
879 * @return string expression SQL
881 function spip_sqlite_date_proche($champ, $interval, $unite)
883 $op = $interval > 0 ?
'>' : '<';
884 return "($champ $op datetime('" . date("Y-m-d H:i:s") . "', '$interval $unite'))";
888 // http://doc.spip.org/@spip_sqlite_replace
889 function spip_sqlite_replace($table, $couples, $desc=array(), $serveur='',$requeter=true) {
890 if (!$desc) $desc = description_table($table);
891 if (!$desc) die("$table insertion sans description");
892 $fields = isset($desc['field'])?
$desc['field']:array();
894 foreach ($couples as $champ => $val) {
895 $couples[$champ]= _sqlite_calculer_cite($val, $fields[$champ]);
898 // recherche de champs 'timestamp' pour mise a jour auto de ceux-ci
899 $couples = _sqlite_ajouter_champs_timestamp($table, $couples, $desc, $serveur);
901 return spip_sqlite_query("REPLACE INTO $table (" . join(',',array_keys($couples)) . ') VALUES (' .join(',',$couples) . ')', $serveur);
906 // http://doc.spip.org/@spip_sqlite_replace_multi
907 function spip_sqlite_replace_multi($table, $tab_couples, $desc=array(), $serveur='',$requeter=true) {
909 // boucler pour trainter chaque requete independemment
910 foreach ($tab_couples as $couples){
911 $retour = spip_sqlite_replace($table, $couples, $desc, $serveur,$requeter);
913 // renvoie le dernier id
918 // http://doc.spip.org/@spip_sqlite_select
919 function spip_sqlite_select($select, $from, $where='', $groupby='', $orderby='', $limit='', $having='', $serveur='',$requeter=true) {
921 // version() n'est pas connu de sqlite
922 $select = str_replace('version()', 'sqlite_version()',$select);
925 $from = (!is_array($from) ?
$from : _sqlite_calculer_select_as($from));
928 _sqlite_calculer_expression('SELECT', $select, ', ')
929 . _sqlite_calculer_expression('FROM', $from, ', ')
930 . _sqlite_calculer_expression('WHERE', $where)
931 . _sqlite_calculer_expression('GROUP BY', $groupby, ',')
932 . _sqlite_calculer_expression('HAVING', $having)
933 . ($orderby ?
("\nORDER BY " . _sqlite_calculer_order($orderby)) :'')
934 . ($limit ?
"\nLIMIT $limit" : '');
936 return spip_sqlite_query($query, $serveur, $requeter);
940 // http://doc.spip.org/@spip_sqlite_selectdb
941 function spip_sqlite_selectdb($db, $serveur='',$requeter=true) {
944 // interdire la creation d'une nouvelle base,
945 // sauf si on est dans l'installation
946 if (!is_file($f = _DIR_DB
. $db . '.sqlite')
947 && (!defined('_ECRIRE_INSTALL') ||
!_ECRIRE_INSTALL
))
950 // se connecter a la base indiquee
951 // avec les identifiants connus
952 $index = $serveur ?
$serveur : 0;
954 if ($link = spip_connect_db('', '', '', '', '@selectdb@' . $db , $serveur, '', '')){
955 if (($db==$link['db']) && $GLOBALS['connexions'][$index] = $link)
958 spip_log("Impossible de selectionner la base $db", 'sqlite');
965 // http://doc.spip.org/@spip_sqlite_set_charset
966 function spip_sqlite_set_charset($charset, $serveur='',$requeter=true){
967 #spip_log("changement de charset sql : "."SET NAMES "._q($charset));
968 # return spip_sqlite_query("SET NAMES ". spip_sqlite_quote($charset), $serveur); //<-- Passe pas !
972 // http://doc.spip.org/@spip_sqlite_showbase
973 function spip_sqlite_showbase($match, $serveur='',$requeter=true){
974 // type est le type d'entrée : table / index / view
975 // on ne retourne que les tables (?) et non les vues...
976 # ESCAPE non supporte par les versions sqlite <3
977 # return spip_sqlite_query("SELECT name FROM sqlite_master WHERE type='table' AND tbl_name LIKE "._q($match)." ESCAPE '\'", $serveur, $requeter);
978 $match = preg_quote($match);
979 $match = str_replace("\\\_","[[TIRETBAS]]",$match);
980 $match = str_replace("\\\%","[[POURCENT]]",$match);
981 $match = str_replace("_",".",$match);
982 $match = str_replace("%",".*",$match);
983 $match = str_replace("[[TIRETBAS]]","_",$match);
984 $match = str_replace("[[POURCENT]]","%",$match);
986 return spip_sqlite_query("SELECT name FROM sqlite_master WHERE type='table' AND tbl_name REGEXP "._q($match), $serveur, $requeter);
990 // http://doc.spip.org/@spip_sqlite_showtable
991 function spip_sqlite_showtable($nom_table, $serveur='',$requeter=true){
994 'SELECT sql, type FROM'
995 . ' (SELECT * FROM sqlite_master UNION ALL'
996 . ' SELECT * FROM sqlite_temp_master)'
997 . " WHERE tbl_name LIKE '$nom_table'"
998 . " AND type!='meta' AND sql NOT NULL AND name NOT LIKE 'sqlite_%'"
999 . ' ORDER BY substr(type,2,1), name';
1001 $a = spip_sqlite_query($query, $serveur, $requeter);
1003 if (!$requeter) return $a;
1004 if (!($a = spip_sqlite_fetch($a, null, $serveur))) return "";
1005 $vue = ($a['type'] == 'view'); // table | vue
1008 // il faut parser le create
1010 if (!preg_match("/^[^(),]*\((([^()]*(\([^()]*\))?[^()]*)*)\)[^()]*$/", array_shift($a), $r))
1014 if (preg_match("/^(.*?),([^,]*KEY.*)$/s", $dec, $r)) {
1022 foreach (explode(",",$dec) as $v) {
1023 preg_match("/^\s*([^\s]+)\s+(.*)/",$v,$r);
1024 // trim car 'Sqlite Manager' (plugin Firefox) utilise des guillemets
1025 // lorsqu'on modifie une table avec cet outil.
1026 // possible que d'autres fassent de meme.
1027 $fields[ trim(strtolower($r[1]),'"') ] = $r[2];
1029 // key inclues dans la requete
1031 foreach(preg_split('/\)\s*,?/',$namedkeys) as $v) {
1032 if (preg_match("/^\s*([^(]*)\((.*)$/",$v,$r)) {
1033 $k = str_replace("`", '', trim($r[1]));
1034 $t = trim(strtolower(str_replace("`", '', $r[2])), '"');
1035 if ($k && !isset($keys[$k])) $keys[$k] = $t; else $keys[] = $t;
1038 // sinon ajouter les key index
1040 'SELECT name,sql FROM'
1041 . ' (SELECT * FROM sqlite_master UNION ALL'
1042 . ' SELECT * FROM sqlite_temp_master)'
1043 . " WHERE tbl_name LIKE '$nom_table'"
1044 . " AND type='index' AND name NOT LIKE 'sqlite_%'"
1045 . 'ORDER BY substr(type,2,1), name';
1046 $a = spip_sqlite_query($query, $serveur, $requeter);
1047 while ($r = spip_sqlite_fetch($a, null, $serveur)) {
1048 $key = str_replace($nom_table.'_','',$r['name']); // enlever le nom de la table ajoute a l'index
1049 $colonnes = preg_replace(',.*\((.*)\).*,','$1',$r['sql']);
1050 $keys['KEY '.$key] = $colonnes;
1053 // c'est une vue, on liste les champs disponibles simplement
1055 if ($res = sql_fetsel('*',$nom_table,'','','','1','',$serveur)){ // limit 1
1057 foreach($res as $c=>$v) $fields[$c]='';
1063 return array('field' => $fields, 'key' => $keys);
1068 // http://doc.spip.org/@spip_sqlite_update
1069 function spip_sqlite_update($table, $champs, $where='', $desc='', $serveur='',$requeter=true) {
1070 // recherche de champs 'timestamp' pour mise a jour auto de ceux-ci
1071 $champs = _sqlite_ajouter_champs_timestamp($table, $champs, $desc, $serveur);
1074 foreach ($champs as $champ => $val)
1075 $set[] = $champ . "=$val";
1077 return spip_sqlite_query(
1078 _sqlite_calculer_expression('UPDATE', $table, ',')
1079 . _sqlite_calculer_expression('SET', $set, ',')
1080 . _sqlite_calculer_expression('WHERE', $where),
1081 $serveur, $requeter);
1085 // http://doc.spip.org/@spip_sqlite_updateq
1086 function spip_sqlite_updateq($table, $champs, $where='', $desc=array(), $serveur='',$requeter=true) {
1088 if (!$champs) return;
1089 if (!$desc) $desc = description_table($table);
1090 if (!$desc) die("$table insertion sans description");
1091 $fields = $desc['field'];
1093 // recherche de champs 'timestamp' pour mise a jour auto de ceux-ci
1094 $champs = _sqlite_ajouter_champs_timestamp($table, $champs, $desc, $serveur);
1097 foreach ($champs as $champ => $val) {
1098 $set[] = $champ . '=' . _sqlite_calculer_cite($val, $fields[$champ]);
1100 return spip_sqlite_query(
1101 _sqlite_calculer_expression('UPDATE', $table, ',')
1102 . _sqlite_calculer_expression('SET', $set, ',')
1103 . _sqlite_calculer_expression('WHERE', $where),
1104 $serveur, $requeter);
1111 * Ensuite les fonctions non abstraites
1112 * crees pour l'occasion de sqlite
1117 // fonction pour la premiere connexion a un serveur SQLite
1118 // http://doc.spip.org/@_sqlite_init
1119 function _sqlite_init(){
1120 if (!defined('_DIR_DB')) define('_DIR_DB', _DIR_ETC
. 'bases/');
1121 if (!defined('_SQLITE_CHMOD')) define('_SQLITE_CHMOD', _SPIP_CHMOD
);
1123 if (!is_dir($d = _DIR_DB
)){
1124 include_spip('inc/flock');
1125 sous_repertoire($d);
1130 // teste la version sqlite du link en cours
1131 // http://doc.spip.org/@_sqlite_is_version
1132 function _sqlite_is_version($version='', $link='', $serveur='',$requeter=true){
1133 if ($link==='') $link = _sqlite_link($serveur);
1134 if (!$link) return false;
1135 if (is_a($link, 'PDO')){
1141 if (!$version) return $v;
1142 return ($version == $v);
1146 // retrouver un link (et definir les fonctions externes sqlite->php)
1147 // $recharger devient inutile (a supprimer ?)
1148 // http://doc.spip.org/@_sqlite_link
1149 function _sqlite_link($serveur = '', $recharger = false){
1150 static $charge = array();
1151 if ($recharger) $charge[$serveur] = false;
1153 $link = &$GLOBALS['connexions'][$serveur ?
$serveur : 0]['link'];
1155 if ($link && !$charge[$serveur]){
1156 include_spip('req/sqlite_fonctions');
1157 _sqlite_init_functions($link);
1158 $charge[$serveur] = true;
1164 /* ordre alphabetique pour les autres */
1167 // renvoie les bons echappements (pas sur les fonctions now())
1168 // http://doc.spip.org/@_sqlite_calculer_cite
1169 function _sqlite_calculer_cite($v, $type) {
1170 if (sql_test_date($type) AND preg_match('/^\w+\(/', $v))
1172 if (sql_test_int($type)) {
1175 if (ctype_xdigit(substr($v,2)) AND strncmp($v,'0x',2)==0)
1176 return hexdec(substr($v,2));
1178 //else return ("'" . spip_sqlite_quote($v) . "'");
1179 return (spip_sqlite_quote($v));
1183 // renvoie grosso modo "$expression join($join, $v)"
1184 // http://doc.spip.org/@_sqlite_calculer_expression
1185 function _sqlite_calculer_expression($expression, $v, $join = 'AND'){
1189 $exp = "\n$expression ";
1191 if (!is_array($v)) {
1194 if (strtoupper($join) === 'AND')
1195 return $exp . join("\n\t$join ", array_map('_sqlite_calculer_where', $v));
1197 return $exp . join($join, $v);
1204 // pour conversion 0+x ? (pas la peine en sqlite)
1205 // http://doc.spip.org/@_sqlite_calculer_order
1206 function _sqlite_calculer_order($orderby) {
1207 return (is_array($orderby)) ?
join(", ", $orderby) : $orderby;
1211 // renvoie des 'nom AS alias'
1212 // http://doc.spip.org/@_sqlite_calculer_select_as
1213 function _sqlite_calculer_select_as($args){
1215 foreach($args as $k => $v) {
1216 if (substr($k,-1)=='@') {
1217 // c'est une jointure qui se refere au from precedent
1222 if (!is_numeric($k)) {
1223 $p = strpos($v, " ");
1225 $v = substr($v,0,$p) . " AS '$k'" . substr($v,$p);
1226 else $v .= " AS '$k'";
1231 return substr($res,2) . $join;
1235 // renvoie les bonnes parentheses pour des where imbriquees
1236 // http://doc.spip.org/@_sqlite_calculer_where
1237 function _sqlite_calculer_where($v){
1241 $op = array_shift($v);
1242 if (!($n=count($v)))
1245 $arg = _sqlite_calculer_where(array_shift($v));
1249 $arg2 = _sqlite_calculer_where(array_shift($v));
1251 return "($arg $op $arg2)";
1252 } else return "($arg $op ($arg2) : $v[0])";
1260 * Charger les modules sqlite (si possible) (juste la version demandee),
1261 * ou, si aucune version, renvoie les versions sqlite dispo
1262 * sur ce serveur dans un array
1264 // http://doc.spip.org/@_sqlite_charger_version
1265 function _sqlite_charger_version($version=''){
1266 $versions = array();
1269 if (!$version ||
$version == 2){
1270 if (charger_php_extension('sqlite')) {
1276 if (!$version ||
$version == 3){
1277 if (charger_php_extension('pdo') && charger_php_extension('pdo_sqlite')) {
1281 if ($version) return in_array($version, $versions);
1288 * Gestion des requetes ALTER non reconnues de SQLite :
1289 * ALTER TABLE table DROP column
1290 * ALTER TABLE table CHANGE [COLUMN] columnA columnB definition
1291 * ALTER TABLE table MODIFY column definition
1292 * ALTER TABLE table ADD|DROP PRIMARY KEY
1294 * (MODIFY transforme en CHANGE columnA columnA) par spip_sqlite_alter()
1296 * 1) creer une table B avec le nouveau format souhaite
1297 * 2) copier la table d'origine A vers B
1298 * 3) supprimer la table A
1299 * 4) renommer la table B en A
1300 * 5) remettre les index (qui sont supprimes avec la table A)
1302 * @param string/array $table : nom_table, array(nom_table=>nom_futur)
1303 * @param string/array $col : nom_colonne, array(nom_colonne=>nom_futur)
1304 * @param array $opt : options comme les tables spip, qui sera merge a la table creee : array('field'=>array('nom'=>'syntaxe', ...), 'key'=>array('KEY nom'=>'colonne', ...))
1305 * @param string $serveur : nom de la connexion sql en cours
1308 // http://doc.spip.org/@_sqlite_modifier_table
1309 function _sqlite_modifier_table($table, $colonne, $opt=array(), $serveur=''){
1311 if (is_array($table)) {
1312 $table_origine = array_shift(array_keys($table));
1313 $table_destination = array_shift($table);
1315 $table_origine = $table_destination = $table;
1317 // ne prend actuellement qu'un changement
1318 // mais pourra etre adapte pour changer plus qu'une colonne a la fois
1319 if (is_array($colonne)) {
1320 $colonne_origine = array_shift(array_keys($colonne));
1321 $colonne_destination = array_shift($colonne);
1323 $colonne_origine = $colonne_destination = $colonne;
1325 if (!isset($opt['field'])) $opt['field'] = array();
1326 if (!isset($opt['key'])) $opt['key'] = array();
1328 // si les noms de tables sont differents, pas besoin de table temporaire
1329 // on prendra directement le nom de la future table
1330 $meme_table = ($table_origine == $table_destination);
1332 $def_origine = sql_showtable($table_origine, false, $serveur);
1333 $table_tmp = $table_origine . '_tmp';
1335 // 1) creer une table temporaire avec les modifications
1336 // - DROP : suppression de la colonne
1337 // - CHANGE : modification de la colonne
1338 // (foreach pour conserver l'ordre des champs)
1342 // pour le INSERT INTO plus loin
1343 // stocker la correspondance nouvelles->anciennes colonnes
1344 $fields_correspondances = array();
1345 foreach ($def_origine['field'] as $c=>$d){
1347 if ($colonne_origine && ($c == $colonne_origine)) {
1349 if ($colonne_destination){
1350 $fields[$colonne_destination] = $opt['field'][$colonne_destination];
1351 $fields_correspondances[$colonne_destination] = $c;
1355 $fields_correspondances[$c] = $c;
1358 // cas de ADD sqlite2 (ajout du champ en fin de table):
1359 if (!$colonne_origine && $colonne_destination){
1360 $fields[$colonne_destination] = $opt['field'][$colonne_destination];
1365 foreach ($def_origine['key'] as $c=>$d){
1366 $c = str_replace($colonne_origine,$colonne_destination,$c);
1367 $d = str_replace($colonne_origine,$colonne_destination,$d);
1368 // seulement si on ne supprime pas la colonne !
1373 // autres keys, on merge
1374 $keys = array_merge($keys,$opt['key']);
1376 $queries[] = 'BEGIN TRANSACTION';
1378 // copier dans destination (si differente de origine), sinon tmp
1379 $table_copie = ($meme_table) ?
$table_tmp : $table_destination;
1381 if ($q = _sqlite_requete_create(
1393 // 2) y copier les champs qui vont bien
1394 $champs_dest = join(', ', array_keys($fields_correspondances));
1395 $champs_ori = join(', ', $fields_correspondances);
1396 $queries[] = "INSERT INTO $table_copie ($champs_dest) SELECT $champs_ori FROM $table_origine";
1398 // 3) supprimer la table d'origine
1399 $queries[] = "DROP TABLE $table_origine";
1401 // 4) renommer la table temporaire
1402 // avec le nom de la table destination
1405 if (_sqlite_is_version(3, '', $serveur)){
1406 $queries[] = "ALTER TABLE $table_copie RENAME TO $table_destination";
1408 $queries[] = _sqlite_requete_create(
1414 $ifnotexists=false, // la table existe puisqu'on est dans une transaction
1416 $queries[] = "INSERT INTO $table_destination SELECT * FROM $table_copie";
1417 $queries[] = "DROP TABLE $table_copie";
1421 // 5) remettre les index !
1422 foreach ($keys as $k=>$v) {
1423 if ($k=='PRIMARY KEY'){}
1427 $queries[] = "CREATE INDEX $table_destination"."_$k ON $table_destination ($v)";
1431 $queries[] = "COMMIT";
1434 // il faut les faire une par une car $query = join('; ', $queries).";"; ne fonctionne pas
1435 foreach ($queries as $q){
1436 $req = new sqlite_traiter_requete($q, $serveur);
1437 if (!$req->executer_requete()){
1438 spip_log("SQLite : ALTER TABLE table :"
1439 ." Erreur a l'execution de la requete : $q",'sqlite');
1453 // http://doc.spip.org/@_sqlite_ref_fonctions
1454 function _sqlite_ref_fonctions(){
1456 'alter' => 'spip_sqlite_alter',
1457 'count' => 'spip_sqlite_count',
1458 'countsel' => 'spip_sqlite_countsel',
1459 'create' => 'spip_sqlite_create',
1460 'create_base' => 'spip_sqlite_create_base',
1461 'create_view' => 'spip_sqlite_create_view',
1462 'date_proche' => 'spip_sqlite_date_proche',
1463 'delete' => 'spip_sqlite_delete',
1464 'drop_table' => 'spip_sqlite_drop_table',
1465 'drop_view' => 'spip_sqlite_drop_view',
1466 'errno' => 'spip_sqlite_errno',
1467 'error' => 'spip_sqlite_error',
1468 'explain' => 'spip_sqlite_explain',
1469 'fetch' => 'spip_sqlite_fetch',
1470 'seek' => 'spip_sqlite_seek',
1471 'free' => 'spip_sqlite_free',
1472 'hex' => 'spip_sqlite_hex',
1473 'in' => 'spip_sqlite_in',
1474 'insert' => 'spip_sqlite_insert',
1475 'insertq' => 'spip_sqlite_insertq',
1476 'insertq_multi' => 'spip_sqlite_insertq_multi',
1477 'listdbs' => 'spip_sqlite_listdbs',
1478 'multi' => 'spip_sqlite_multi',
1479 'optimize' => 'spip_sqlite_optimize',
1480 'query' => 'spip_sqlite_query',
1481 'quote' => 'spip_sqlite_quote',
1482 'replace' => 'spip_sqlite_replace',
1483 'replace_multi' => 'spip_sqlite_replace_multi',
1484 'select' => 'spip_sqlite_select',
1485 'selectdb' => 'spip_sqlite_selectdb',
1486 'set_charset' => 'spip_sqlite_set_charset',
1487 'get_charset' => 'spip_sqlite_get_charset',
1488 'showbase' => 'spip_sqlite_showbase',
1489 'showtable' => 'spip_sqlite_showtable',
1490 'update' => 'spip_sqlite_update',
1491 'updateq' => 'spip_sqlite_updateq',
1494 // association de chaque nom http d'un charset aux couples sqlite
1495 // SQLite supporte utf-8 et utf-16 uniquement.
1497 'utf-8'=>array('charset'=>'utf8','collation'=>'utf8_general_ci'),
1498 //'utf-16be'=>array('charset'=>'utf16be','collation'=>'UTF-16BE'),// aucune idee de quoi il faut remplir dans es champs la
1499 //'utf-16le'=>array('charset'=>'utf16le','collation'=>'UTF-16LE')
1502 $fonctions['charsets'] = $charsets;
1509 // $query est une requete ou une liste de champs
1510 // http://doc.spip.org/@_sqlite_remplacements_definitions_table
1511 function _sqlite_remplacements_definitions_table($query,$autoinc=false){
1512 // quelques remplacements
1513 $num = "(\s*\([0-9]*\))?";
1514 $enum = "(\s*\([^\)]*\))?";
1517 '/enum'.$enum.'/is' => 'VARCHAR',
1519 '/COLLATE \w+_bin/is' => '',
1520 '/auto_increment/is' => '',
1521 '/(timestamp .* )ON .*$/is' => '\\1',
1522 '/character set \w+/is' => '',
1523 '/((big|small|medium|tiny)?int(eger)?)'.$num.'\s*unsigned/is' => '\\1 UNSIGNED',
1524 '/(text\s+not\s+null)\s*$/is' => "\\1 DEFAULT ''",
1527 // pour l'autoincrement, il faut des INTEGER NOT NULL PRIMARY KEY
1529 $remplace['/(big|small|medium|tiny)?int(eger)?'.$num.'/is'] = 'INTEGER';
1531 return preg_replace(array_keys($remplace), $remplace, $query);
1536 * Creer la requete pour la creation d'une table
1537 * retourne la requete pour utilisation par sql_create() et sql_alter()
1539 // http://doc.spip.org/@_sqlite_requete_create
1540 function _sqlite_requete_create($nom, $champs, $cles, $autoinc=false, $temporary=false, $_ifnotexists=true, $serveur='',$requeter=true) {
1541 $query = $keys = $s = $p = '';
1543 // certains plugins declarent les tables (permet leur inclusion dans le dump)
1544 // sans les renseigner (laisse le compilo recuperer la description)
1545 if (!is_array($champs) ||
!is_array($cles))
1548 // sqlite ne gere pas KEY tout court dans une requete CREATE TABLE
1549 // il faut passer par des create index
1550 // Il gere par contre primary key !
1551 // Soit la PK est definie dans les cles, soit dans un champs
1552 if (!$c = $cles[$pk = "PRIMARY KEY"]) {
1553 foreach($champs as $k => $v) {
1554 if (false !== stripos($v,$pk)) {
1556 // on n'en a plus besoin dans field, vu que defini dans key
1557 $champs[$k] = preg_replace("/$pk/is", '', $champs[$k]);
1562 if ($c) $keys = "\n\t\t$pk ($c)";
1564 $champs = _sqlite_remplacements_definitions_table($champs, $autoinc);
1565 foreach($champs as $k => $v) {
1566 $query .= "$s\n\t\t$k $v";
1571 if ($_ifnotexists) {
1572 // simuler le IF NOT EXISTS - version 2
1573 if (_sqlite_is_version(2, '', $serveur)){
1574 $a = spip_sqlite_showtable($nom, $serveur);
1575 if ($a) return false;
1577 // sinon l'ajouter en version 3
1579 $ifnotexists = ' IF NOT EXISTS';
1583 $temporary = $temporary ?
' TEMPORARY':'';
1584 $q = "CREATE$temporary TABLE$ifnotexists $nom ($query" . ($keys ?
",$keys" : '') . ")\n";
1592 * Retrouver les champs 'timestamp'
1593 * pour les ajouter aux 'insert' ou 'replace'
1594 * afin de simuler le fonctionnement de mysql
1596 * stocke le resultat pour ne pas faire
1597 * de requetes showtable intempestives
1599 // http://doc.spip.org/@_sqlite_ajouter_champs_timestamp
1600 function _sqlite_ajouter_champs_timestamp($table, $couples, $desc='', $serveur=''){
1601 static $tables = array();
1603 if (!isset($tables[$table])){
1606 $f = charger_fonction('trouver_table', 'base');
1607 $desc = $f($table, $serveur);
1608 // si pas de description, on ne fait rien, ou on die() ?
1609 if (!$desc OR !$desc['field']) return $couples;
1612 // recherche des champs avec simplement 'TIMESTAMP'
1613 // cependant, il faudra peut etre etendre
1614 // avec la gestion de DEFAULT et ON UPDATE
1615 // mais ceux-ci ne sont pas utilises dans le core
1616 $tables[$table] = array();
1618 foreach ($desc['field'] as $k=>$v){
1619 if (strpos(strtolower(ltrim($v)), 'timestamp')===0)
1620 $tables[$table][] = $k;
1624 // ajout des champs type 'timestamp' absents
1625 foreach ($tables[$table] as $maj){
1626 if (!array_key_exists($maj, $couples))
1627 $couples[$maj] = "datetime('now')";
1635 * renvoyer la liste des versions sqlite disponibles
1638 // http://doc.spip.org/@spip_versions_sqlite
1639 function spip_versions_sqlite(){
1640 return _sqlite_charger_version();
1647 * Classe pour partager les lancements de requete
1648 * - peut corriger la syntaxe des requetes pour la conformite a sqlite
1649 * - peut tracer les requetes
1651 * Cette classe est presente essentiellement pour un preg_replace_callback
1652 * avec des parametres dans la fonction appelee que l'on souhaite incrementer
1653 * (fonction pour proteger les textes)
1656 class sqlite_traiter_requete
{
1657 var $query = ''; // la requete
1658 var $queryCount = ''; // la requete pour compter
1659 var $serveur = ''; // le serveur
1660 var $link = ''; // le link (ressource) sqlite
1661 var $prefixe = ''; // le prefixe des tables
1662 var $db = ''; // le nom de la base
1663 var $tracer = false; // doit-on tracer les requetes (var_profile)
1665 var $sqlite_version = ''; // Version de sqlite (2 ou 3)
1667 // Pour les corrections a effectuer sur les requetes :
1668 var $textes = array(); // array(code=>'texte') trouvé
1669 var $codeEchappements = "%@##@%";
1673 // http://doc.spip.org/@sqlite_traiter_requete
1674 function sqlite_traiter_requete($query, $serveur = ''){
1675 $this->query
= $query;
1676 $this->serveur
= strtolower($serveur);
1678 if (!($this->link
= _sqlite_link($this->serveur
)) && (!defined('_ECRIRE_INSTALL') ||
!_ECRIRE_INSTALL
)){
1679 spip_log("Aucune connexion sqlite (link)");
1683 $this->sqlite_version
=_sqlite_is_version('', $this->link
);
1685 $this->prefixe
= $GLOBALS['connexions'][$this->serveur ?
$this->serveur
: 0]['prefixe'];
1686 $this->db
= $GLOBALS['connexions'][$this->serveur ?
$this->serveur
: 0]['db'];
1688 // tracage des requetes ?
1689 $this->tracer
= (isset($_GET['var_profile']) && $_GET['var_profile']);
1693 // lancer la requete $this->query,
1694 // faire le tracage si demande
1695 // http://doc.spip.org/@executer_requete
1696 function executer_requete(){
1698 if ($this->tracer
) {
1699 include_spip('public/tracer');
1700 $t = trace_query_start();
1703 # spip_log("requete: $this->serveur >> $this->query",'query'); // boum ? pourquoi ?
1705 // memoriser la derniere erreur PHP vue
1706 $e = error_get_last();
1707 // sauver la derniere requete
1708 $GLOBALS['connexions'][$this->serveur ?
$this->serveur
: 0]['last'] = $this->query
;
1710 if ($this->sqlite_version
== 3) {
1711 $r = $this->link
->query($this->query
);
1712 // sauvegarde de la requete (elle y est deja dans $r->queryString)
1713 # $r->spipQueryString = $this->query;
1715 // comptage : oblige de compter le nombre d'entrees retournees
1716 // par une requete SELECT
1717 // aucune autre solution ne donne le nombre attendu :( !
1718 // particulierement s'il y a des LIMIT dans la requete.
1719 if (strtoupper(substr(ltrim($this->query
),0,6)) == 'SELECT'){
1721 $l = $this->link
->query($this->query
);
1722 $r->spipSqliteRowCount
= count($l->fetchAll());
1724 } elseif (is_a($r, 'PDOStatement')) {
1725 $r->spipSqliteRowCount
= 0;
1729 $r = sqlite_query($this->link
, $this->query
);
1732 // loger les warnings/erreurs eventuels de sqlite remontant dans PHP
1733 if ($err = error_get_last() AND $err!=$e) {
1734 $err = strip_tags($err['message'])." in ".$err['file']." line ".$err['line'];
1735 spip_log("$err - ".$this->query
, 'sqlite');
1743 if (spip_sqlite_errno($serveur))
1744 $err .= spip_sqlite_error($this->query
, $serveur);
1745 return $t ?
trace_query_end($this->query
, $t, $r, $err, $serveur) : $r;
1748 // transformer la requete pour sqlite
1749 // enleve les textes, transforme la requete pour quelle soit
1750 // bien interpretee par sqlite, puis remet les textes
1751 // la fonction affecte $this->query
1752 // http://doc.spip.org/@traduire_requete
1753 function traduire_requete(){
1755 // 1) Protection des textes en les remplacant par des codes
1757 // enlever les echappements ''
1758 $this->query
= str_replace("''", $this->codeEchappements
, $this->query
);
1759 // enlever les 'textes'
1760 $this->textes
= array(); // vider
1761 $this->query
= preg_replace_callback("/('[^']*')/", array(&$this, '_remplacerTexteParCode'), $this->query
);
1764 // 2) Corrections de la requete
1766 // Correction Create Database
1767 // Create Database -> requete ignoree
1768 if (strpos($this->query
, 'CREATE DATABASE')===0){
1769 spip_log("Sqlite : requete non executee -> $this->query","sqlite");
1770 $this->query
= "SELECT 1";
1773 // Correction Insert Ignore
1774 // INSERT IGNORE -> insert (tout court et pas 'insert or replace')
1775 if (strpos($this->query
, 'INSERT IGNORE')===0){
1776 #spip_log("Sqlite : requete transformee -> $this->query","sqlite");
1777 $this->query
= 'INSERT ' . substr($this->query
,'13');
1780 // Correction des dates avec INTERVAL
1781 // utiliser sql_date_proche() de preference
1782 if (strpos($this->query
, 'INTERVAL')!==false){
1783 $this->query
= preg_replace_callback("/DATE_(ADD|SUB).*INTERVAL\s+(\d+)\s+([a-zA-Z]+)\)/U",
1784 array(&$this, '_remplacerDateParTime'),
1789 // USING (non reconnu en sqlite2)
1790 // problematique car la jointure ne se fait pas du coup.
1791 if (($this->sqlite_version
== 2) && (strpos($this->query
, "USING")!==false)) {
1792 spip_log("'USING (champ)' n'est pas reconnu en SQLite 2. Utilisez 'ON table1.champ = table2.champ', 'sqlite'");
1793 $this->query
= preg_replace('/USING\s*\([^\)]*\)/', '', $this->query
);
1797 // remplace FIELD(table,i,j,k...) par CASE WHEN table=i THEN n ... ELSE 0 END
1798 if (strpos($this->query
, 'FIELD')!==false){
1799 $this->query
= preg_replace_callback('/FIELD\s*\(([^\)]*)\)/',
1800 array(&$this, '_remplacerFieldParCase'),
1804 // Correction des noms de tables FROM
1805 // mettre les bons noms de table dans from, update, insert, replace...
1806 if (preg_match('/\s(SET|VALUES|WHERE|DATABASE)\s/i', $this->query
, $regs)) {
1807 $suite = strstr($this->query
, $regs[0]);
1808 $this->query
= substr($this->query
, 0, -strlen($suite));
1810 $pref = ($this->prefixe
) ?
$this->prefixe
. "_": "";
1811 $this->query
= preg_replace('/([,\s])spip_/', '\1'.$pref, $this->query
) . $suite;
1813 // Correction zero AS x
1814 // pg n'aime pas 0+x AS alias, sqlite, dans le meme style,
1815 // n'apprecie pas du tout SELECT 0 as x ... ORDER BY x
1816 // il dit que x ne doit pas ĂȘtre un integer dans le order by !
1817 // on remplace du coup x par vide() dans ce cas uniquement
1819 // rien que pour public/vertebrer.php ?
1820 if ((strpos($this->query
, "0 AS")!==false)){
1821 // on ne remplace que dans ORDER BY ou GROUP BY
1822 if (preg_match('/\s(ORDER|GROUP) BY\s/i', $this->query
, $regs)) {
1823 $suite = strstr($this->query
, $regs[0]);
1824 $this->query
= substr($this->query
, 0, -strlen($suite));
1826 // on cherche les noms des x dans 0 AS x
1827 // on remplace dans $suite le nom par vide()
1828 preg_match_all('/\b0 AS\s*([^\s,]+)/', $this->query
, $matches, PREG_PATTERN_ORDER
);
1829 foreach ($matches[1] as $m){
1830 $suite = str_replace($m, 'VIDE()', $suite);
1832 $this->query
.= $suite;
1836 // Correction possible des divisions entieres
1837 // Le standard SQL (lequel? ou?) semble indiquer que
1838 // a/b=c doit donner c entier si a et b sont entiers 4/3=1.
1839 // C'est ce que retournent effectivement SQL Server et SQLite
1840 // Ce n'est pas ce qu'applique MySQL qui retourne un reel : 4/3=1.333...
1842 // On peut forcer la conversion en multipliant par 1.0 avant la division
1843 // /!\ SQLite 3.5.9 Debian/Ubuntu est victime d'un bug en plus !
1844 // cf. https://bugs.launchpad.net/ubuntu/+source/sqlite3/+bug/254228
1845 // http://www.sqlite.org/cvstrac/tktview?tn=3202
1846 // (4*1.0/3) n'est pas rendu dans ce cas !
1847 # $this->query = str_replace('/','* 1.00 / ',$this->query);
1849 // Correction Antiquotes
1851 $this->query
= str_replace('`','',$this->query
);
1853 // Correction critere REGEXP, non reconnu en sqlite2
1854 if (($this->sqlite_version
== 2) && (strpos($this->query
, 'REGEXP')!==false)){
1855 $this->query
= preg_replace('/([^\s\(]*)(\s*)REGEXP(\s*)([^\s\)]*)/', 'REGEXP($4, $1)', $this->query
);
1860 // 3) Remise en place des textes d'origine
1862 // remettre les 'textes'
1863 foreach ($this->textes
as $cle=>$val){
1864 $this->query
= str_replace($cle, $val, $this->query
);
1866 // remettre les echappements ''
1867 $this->query
= str_replace($this->codeEchappements
,"''",$this->query
);
1873 // remplacer DATE_ / INTERVAL par DATE...strtotime
1874 // http://doc.spip.org/@_remplacerDateParTime
1875 function _remplacerDateParTime($matches){
1876 $op = strtoupper($matches[1] == 'ADD')?
'+':'-';
1877 return "datetime('" . date("Y-m-d H:i:s") . "', '$op$matches[2] $matches[3]')";
1880 // callback ou l'on remplace FIELD(table,i,j,k...) par CASE WHEN table=i THEN n ... ELSE 0 END
1881 // http://doc.spip.org/@_remplacerFieldParCase
1882 function _remplacerFieldParCase($matches){
1883 $fields = substr($matches[0],6,-1); // ne recuperer que l'interieur X de field(X)
1884 $t = explode(',', $fields);
1885 $index = array_shift($t);
1891 $res .= "\nWHEN $index=$v THEN $n";
1893 return "CASE $res ELSE 0 END ";
1896 // callback ou l'on sauve le texte qui est cache dans un tableau $this->textes
1897 // http://doc.spip.org/@_remplacerTexteParCode
1898 function _remplacerTexteParCode($matches){
1899 $this->textes
[$code = "%@##".count($this->textes
)."##@%"] = $matches[1];